home *** CD-ROM | disk | FTP | other *** search
/ CD ROM Paradise Collection 4 / CD ROM Paradise Collection 4 1995 Nov.iso / graphics / font3d10.zip / Vector.H < prev   
C/C++ Source or Header  |  1994-09-15  |  5KB  |  196 lines
  1. //=================================================================================================
  2. //   Vector.H
  3. //
  4. //   Copyright (c) 1994 by Todd A. Prater
  5. //   All rights reserved.
  6. //
  7. //-------------------------------------------------------------------------------------------------
  8. //
  9. //   A vector class.
  10. //
  11. //   Constructors:
  12. //
  13. //      VECTOR(void)
  14. //      VECTOR(DOUBLE,DOUBLE,DOUBLE)
  15. //      VECTOR(VECTOR&)
  16. //
  17. //   Member Operators:
  18. //
  19. //      +=     Assign Sum
  20. //      -=     Assign Difference
  21. //      *=     Assign Product
  22. //      /=     Assign Quotient 
  23. //
  24. //   Non-Member Operators:
  25. //
  26. //      +      Sum            Binary      (VECTOR + VECTOR) -> VECTOR
  27. //      -      Difference     Binary      (VECTOR - VECTOR) -> VECTOR
  28. //      *      Scale          Binary      (VECTOR * DOUBLE) -> VECTOR
  29. //      *      Scale          Binary      (DOUBLE * VECTOR) -> VECTOR
  30. //      /      Scale          Binary      (VECTOR / DOUBLE) -> VECTOR
  31. //      %      Dot Product    Binary      (VECTOR % VECTOR) -> DOUBLE
  32. //      ^      Cross Product  Binary      (VECTOR ^ VECTOR) -> VECTOR
  33. //      ~      Normalize      Unary       (~VECTOR)         -> VECTOR
  34. //      -      Negative       Unary       (-VECTOR)         -> VECTOR
  35. //
  36. //      ==     Equal to       Binary      (VECTOR == VECTOR) -> INT
  37. //      !=     Not equal to   Binary      (VECTOR !- VECTOR) -> INT
  38. //
  39. //      >>     Insertion      Binary      (ostream& >> VECTOR&) -> ostream&
  40. //
  41. //   Non-Member Functions:
  42. //
  43. //      dist(VECTOR x, VECTOR y) ...... Returns the distance between x and y.
  44. //
  45. //
  46. //=================================================================================================
  47.  
  48. #ifndef __Vector_H__
  49. #define __Vector_H__
  50.  
  51.    #include <math.h>
  52.    #include <iostream.h>
  53.    #include "Config.H"
  54.  
  55.    class VECTOR
  56.    {
  57.      public:  DOUBLE  x,y,z;
  58.  
  59.               VECTOR ();
  60.               VECTOR (const DOUBLE& _x, const DOUBLE& _y, const DOUBLE& _z);
  61.               VECTOR (const VECTOR& v);
  62.  
  63.               VECTOR& operator += (const VECTOR& v);
  64.               VECTOR& operator -= (const VECTOR& v);
  65.               VECTOR& operator *= (const DOUBLE& f);
  66.               VECTOR& operator /= (const DOUBLE& f);
  67.    };
  68.  
  69.  
  70.    //_____ CONSTRUCTORS _____
  71.  
  72.  
  73.    inline VECTOR::VECTOR(void)
  74.    {
  75.      x=0;y=0;z=0;
  76.    }
  77.  
  78.    inline VECTOR::VECTOR(const DOUBLE& _x, const DOUBLE& _y, const DOUBLE& _z)
  79.    {
  80.      x=_x;y=_y;z=_z;
  81.    }
  82.  
  83.    inline VECTOR::VECTOR(const VECTOR& v)
  84.    {
  85.      x=v.x;y=v.y;z=v.z;
  86.    }
  87.  
  88.  
  89.    //_____ NON-MEMBER FUNCTIONS _____
  90.  
  91.  
  92.    inline VECTOR operator + (VECTOR v1, VECTOR v2)
  93.    {
  94.      return VECTOR(v1.x+v2.x,v1.y+v2.y,v1.z+v2.z);
  95.    }
  96.  
  97.    inline VECTOR operator - (VECTOR v1, VECTOR v2)
  98.    {
  99.      return VECTOR(v1.x-v2.x,v1.y-v2.y,v1.z-v2.z);
  100.    }
  101.  
  102.    inline VECTOR operator * (VECTOR v, DOUBLE f)
  103.    {
  104.      return VECTOR(v.x*f,v.y*f,v.z*f);
  105.    }
  106.  
  107.    inline VECTOR operator * (DOUBLE f, VECTOR v)
  108.    {
  109.      return VECTOR(v.x*f,v.y*f,v.z*f);
  110.    }
  111.  
  112.    inline VECTOR operator / (VECTOR v, DOUBLE f)
  113.    {
  114.      return VECTOR(v.x/f,v.y/f,v.z/f);
  115.    }
  116.  
  117.    inline DOUBLE operator % (VECTOR v1, VECTOR v2)
  118.    {
  119.      return (v1.x*v2.x+v1.y*v2.y+v1.z*v2.z);
  120.    }
  121.  
  122.    inline VECTOR operator ^ (VECTOR v1, VECTOR v2)
  123.    {
  124.      DOUBLE  tx = v1.y*v2.z - v1.z*v2.y;
  125.      DOUBLE  ty = v1.z*v2.x - v1.x*v2.z;
  126.      DOUBLE  tz = v1.x*v2.y - v1.y*v2.x;
  127.      return  VECTOR(tx,ty,tz);
  128.    }
  129.  
  130.    inline VECTOR operator ~ (VECTOR v)
  131.    {
  132.      DOUBLE  mag = sqrt(v.x*v.x + v.y*v.y + v.z*v.z);
  133.      DOUBLE  tx = v.x/mag;
  134.      DOUBLE  ty = v.y/mag;
  135.      DOUBLE  tz = v.z/mag;
  136.      return  VECTOR(tx,ty,tz);
  137.    }
  138.  
  139.    inline VECTOR operator - (VECTOR v)
  140.    {
  141.      return VECTOR(-v.x,-v.y,-v.z);
  142.    }
  143.  
  144.    inline int operator == (VECTOR v1, VECTOR v2)
  145.    {
  146.      return (v1.x==v2.x&&v1.y==v2.y&&v1.z==v2.z);
  147.    }
  148.  
  149.    inline int operator != (VECTOR v1, VECTOR v2)
  150.    {
  151.      return (v1.x!=v2.x&&v1.y!=v2.y&&v1.z!=v2.z);
  152.    }
  153.  
  154.  
  155.    inline DOUBLE dist (VECTOR v1, VECTOR v2)
  156.    {
  157.      VECTOR d = v2-v1;
  158.      return (sqrt(d%d));
  159.    }
  160.  
  161.  
  162.    //_____ MEMBER SHORTHAND OPERATORS _____
  163.  
  164.    inline VECTOR& VECTOR::operator += (const VECTOR& v)
  165.    {
  166.      x+=v.x; y+=v.y; z+=v.z;
  167.      return *this;
  168.    }
  169.  
  170.    inline VECTOR& VECTOR::operator -= (const VECTOR& v)
  171.    {
  172.      x-=v.x; y-=v.y; z-=v.z;
  173.      return *this;
  174.    }
  175.  
  176.    inline VECTOR& VECTOR::operator *= (const DOUBLE& f)
  177.    {
  178.      x*=f; y*=f; z*=f;
  179.      return *this;
  180.    }
  181.  
  182.    inline VECTOR& VECTOR::operator /= (const DOUBLE& f)
  183.    {
  184.      x/=f; y/=f; z/=f;
  185.      return *this;
  186.    }
  187.  
  188.    inline ostream& operator << (ostream& s, const VECTOR& v)
  189.    {
  190.       s<<"<"<<v.x<<","<<v.y<<","<<v.z<<">";
  191.       return s;
  192.    }
  193.  
  194.  
  195. #endif
  196.